using System;
using System.Data;
using System.Collections.Generic;
using System.Collections;
using System.Data.Common;

using ACFramework;

namespace ACSeguridad
{
   public class ACUsuarios
   {
      #region Variables
      DAEnterpriseValidate DAEntrerprise;
      private EUsuarios e_usuarios;
      private List<EUsuarios> m_listUsuarios;
      private DataTable m_dtUsuarios;
      private ACTypeConsulta m_consulta;
      private ACDataConexion m_dc;
      private String m_formatofecha;

      public static String Tabla
      {
         get { return "Usuarios"; }
      }
      public static String Esquema
      {
         get { return "dbo"; }
      }
      		
      #endregion

      #region Constructores
      public ACUsuarios(ACDataConexion _dc)
      {
         DAEnterpriseValidate.Instanciar(_dc.Servidor, _dc.BaseDatos, _dc.UsuarioBD, _dc.PasswordBD);
         m_dc = _dc;
         m_formatofecha = "yyyy-dd-MM HH:mm:ss.fff";
      }

      #endregion

      #region Propiedades
      public List<EUsuarios> ListUsuarios
      {
         get { return m_listUsuarios; }
         set { m_listUsuarios = value; }
      }
      public EUsuarios Usuarios
      {
         get { return e_usuarios; }
         set { e_usuarios = value; }
      }
      #endregion

      #region facade
      public bool CargarTodos()
      {
         try
         {
            m_listUsuarios = new List<EUsuarios>();
            return USERSS_Todos(ref m_listUsuarios);
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }

      public bool CargarTodosDT()
      {
         try
         {
            m_dtUsuarios = new DataTable();
            return USERSS_Todos(ref m_dtUsuarios);
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }

      public bool CargarTodos(Hashtable x_where)
      {
         try
         {
            m_listUsuarios = new List<EUsuarios>();
            return USERSS_Todos(ref m_listUsuarios, x_where);
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }
      
      public bool CargarTodos(List<ACJoin> x_join, Hashtable x_where)
      {
         try
         {
            m_listUsuarios = new List<EUsuarios>();
            return USERSS_Todos(ref m_listUsuarios, x_join, x_where);
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }

      public bool Cargar(Int32 x_user_id)
      {
         try
         {
            e_usuarios = new EUsuarios();
            return USERSS_UnReg(ref e_usuarios, x_user_id);
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }

      public bool Cargar(String x_user_dni)
      {
         try
         {
            e_usuarios = new EUsuarios();
            Hashtable x_where = new Hashtable();
            x_where.Add("USER_DNI", new ACWhere(x_user_dni, ACWhere.TipoWhere.Igual, true));
            return USERSS_UnReg(ref e_usuarios, x_where);
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }

      public bool Cargar(List<ACJoin> x_join, Hashtable x_where)
      {
         try
         {
            e_usuarios = new EUsuarios();
            return USERSS_UnReg(ref e_usuarios, x_join, x_where);
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }

      #endregion

      #region Cargar Usuarios

      #region Procedimientos Almacenados

      private bool USERSS_Todos(ref DataTable dt_datos)
      {
         try
         {
            DataSet m_datos = new DataSet();

            DAEnterpriseValidate.AsignarProcedure(getSelectAll(), CommandType.Text);
            m_datos = DAEnterpriseValidate.ExecuteDataSet();
            m_datos.Tables[0].TableName = "Usuarios";
            dt_datos = m_datos.Tables[0];
            return (dt_datos.Rows.Count > 0 ? true : false);
         }
         catch (Exception ex)
         { throw ex; }
      }
      private bool USERSS_Todos(ref List<EUsuarios> listEUsuarios, Hashtable x_where)
      {
         try
         {
            DAEnterpriseValidate.AsignarProcedure(getSelectAll(x_where), CommandType.Text);
            using (DbDataReader reader = (DbDataReader)DAEnterpriseValidate.ExecuteDataReader())
            {
               if (reader.HasRows)
               {
                  ACEsquemas _utilitarios = new ACEsquemas(new EUsuarios());
                  while (reader.Read())
                  {
                     EUsuarios e_usuarios = new EUsuarios();
                     _utilitarios.ACCargarEsquemas(reader, e_usuarios);
                     e_usuarios.Instanciar(ACEInstancia.Consulta);
                     listEUsuarios.Add(e_usuarios);
                  }
                  return true;
               }
               else
                  return false;
            }
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }
      private bool USERSS_Todos(ref List<EUsuarios> listEUsuarios, List<ACJoin> x_join, Hashtable x_where)
      {
         try
         {
            DAEnterpriseValidate.AsignarProcedure(getSelectAll(x_join, x_where), CommandType.Text);
            using (DbDataReader reader = (DbDataReader)DAEnterpriseValidate.ExecuteDataReader())
            {
               if (reader.HasRows)
               {
                  ACEsquemas _utilitarios = new ACEsquemas(new EUsuarios());
                  while (reader.Read())
                  {
                     EUsuarios e_usuarios = new EUsuarios();
                     _utilitarios.ACCargarEsquemas(reader, e_usuarios);
                     e_usuarios.Instanciar(ACEInstancia.Consulta);
                     listEUsuarios.Add(e_usuarios);
                  }
                  return true;
               }
               else
               {
                  return false;
               }
            }
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }
      private bool USERSS_Todos(ref List<EUsuarios> x_listusuarios)
      {
         try
         {
            DAEnterpriseValidate.AsignarProcedure(getSelectAll(), CommandType.Text);
            using (DbDataReader reader = (DbDataReader)DAEnterpriseValidate.ExecuteDataReader())
            {
               if (reader.HasRows)
               {
                  ACEsquemas _esquemas = new ACEsquemas(new EUsuarios());
                  while (reader.Read())
                  {
                     EUsuarios x_usuarios = new EUsuarios();
                     _esquemas.ACCargarEsquemas(reader, x_usuarios);
                     x_usuarios.Instanciar(ACEInstancia.Consulta);
                     x_listusuarios.Add(x_usuarios);
                  }
                  return true;
               }
               else
               { return false; }
            }
         }
         catch (Exception ex)
         { throw ex; }
      }
      private bool USERSS_UnReg(ref EUsuarios x_usuarios, Int32 x_user_iduser)
      {
         try
         {

            DAEnterpriseValidate.AsignarProcedure(getSelectBy(x_user_iduser), CommandType.Text);
            using (DbDataReader reader = (DbDataReader)DAEnterpriseValidate.ExecuteDataReader())
            {
               if (reader.HasRows)
               {
                  reader.Read();
                  ACEsquemas.ACCargarEsquema(reader, x_usuarios);
                  return true;
               }
               else
               { return false; }
            }
         }
         catch (Exception ex)
         { throw ex; }
      }
      private bool USERSS_UnReg(ref EUsuarios x_usuarios, Hashtable x_where)
      {
         try
         {
            DAEnterpriseValidate.AsignarProcedure(getSelectAll(x_where), CommandType.Text);
            using (DbDataReader reader = (DbDataReader)DAEnterpriseValidate.ExecuteDataReader())
            {
               if (reader.HasRows)
               {
                  reader.Read();
                  ACEsquemas.ACCargarEsquema(reader, x_usuarios);
                  x_usuarios.Instanciar(ACEInstancia.Consulta);
                  return true;
               }
               else
               {
                  return false;
               }
            }
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }
      private bool USERSS_UnReg(ref EUsuarios x_usuarios, List<ACJoin> x_join, Hashtable x_where)
      {
         try
         {
            DAEnterpriseValidate.AsignarProcedure(getSelectAll(x_join, x_where), CommandType.Text);
            using (DbDataReader reader = (DbDataReader)DAEnterpriseValidate.ExecuteDataReader())
            {
               if (reader.HasRows)
               {
                  reader.Read();
                  ACEsquemas.ACCargarEsquema(reader, x_usuarios);
                  x_usuarios.Instanciar(ACEInstancia.Consulta);
                  return true;
               }
               else
               {
                  return false;
               }
            }
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }
      
      #region Procedimientos Adicionales
      public String getSelectAll()
      {
         try
         {
            string sql = "";
            sql = " SELECT *";
            sql += " FROM dbo.Usuarios";

            return sql;
         }
         catch (Exception ex)
         { throw ex; }
      }

      public String getSelectAll(Hashtable x_where)
      {
         try
         {
            string sql = "";
            sql = String.Format(" SELECT  * {0}", System.Environment.NewLine);
            sql += String.Format(" FROM dbo.Usuarios{0}", System.Environment.NewLine);
            sql += String.Format(" WHERE {0}", System.Environment.NewLine);
            ACGenerador<EUsuarios> _where = new ACGenerador<EUsuarios>("yyyy-MM-dd");
            sql += _where.getWhere(x_where, true);

            return sql;
         }
         catch (Exception ex)
         { throw ex; }
      }

      public String getSelectAll(List<ACJoin> x_join, Hashtable x_where)
      {
         try
         {
            string sql = "";

            ACGenerador<EUsuarios> _join = new ACGenerador<EUsuarios>("yyyy-MM-dd");
            sql += _join.getJoin(Esquema, Tabla, x_join, x_where);

            return sql;
         }
         catch (Exception ex)
         { throw ex; }
      }

      public String getSelectBy(Int32 x_user_iduser)
      {
         try
         {
            string sql = "";
            sql = String.Format(" SELECT * {0}", System.Environment.NewLine);
            sql += String.Format(" FROM dbo.Usuarios{0}", System.Environment.NewLine);
            sql += String.Format(" WHERE {0}", System.Environment.NewLine);
            sql += String.Format("USER_IdUser = {0}{1}", x_user_iduser, System.Environment.NewLine);

            return sql;
         }
         catch (Exception ex)
         { throw ex; }
      }
            
      #endregion

      #endregion

      #region Metodos

      private String getDate()
      {
         DataTable x_datos = new DataTable();
         try
         {
            DAEnterpriseValidate.AsignarProcedure("Select getDate()", CommandType.Text);
            x_datos = DAEnterpriseValidate.ExecuteDataSet().Tables[0];
            DateTime _fecha = (DateTime)x_datos.Rows[0][0];
            return String.Format("'{0}'", _fecha.ToString(m_formatofecha));
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }

      private DateTime getDateTime()
      {
         DataTable x_datos = new DataTable();
         try
         {
            DAEnterpriseValidate.AsignarProcedure("Select getDate()", CommandType.Text);
            x_datos = DAEnterpriseValidate.ExecuteDataSet().Tables[0];
            DateTime _fecha = (DateTime)x_datos.Rows[0][0];
            return _fecha;
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }


      #endregion
   #endregion
   }
}
